Intermediate / 1 to 5 years experienced level questions

For example,

The following expression in Kotlin

val sample1 = sample2 ?: "Undefined"

is equivalent to the following

val sample1 = if(sample2 != null)        
    sample2     
  else        
    "Undefined"

Furthermore, on the right side of the Elvis operator, we may use throw and return expressions, which is particularly handy in functions. As a result, instead of returning a default value on the right side of the Elvis operator, we can throw an exception. For example,

val sample1 = sample2 ?: throw IllegalArgumentException("Invalid")

Not Null Assertion Operator ( !! ) - If the value is null, the not null assertion (!!) operator changes it to a non-null type and throws an exception.

Anyone who wants a NullPointerException can ask for it explicitly with this operator.

For example,

// KOTLIN
fun main(args: Array) {   
  var sample : String?  = null   
  str!!.length
}

The above code snippet gives the following output:-

Exception in thread "main" kotlin.KotlinNullPointerException

• Primary Constructor  - This type of constructor is initialised in the class header and is provided after the class name. It is declared using the “constructor” keyword. Parameters are optional in this type of constructor. For example,

class Sample constructor(val a: Int, val b: Int) {   
  // code
}

If no annotations or access modifiers are provided, the constructor keyword can be omitted. The initialization code can be placed in a separate initializer block prefixed with the init keyword because the primary constructor cannot contain any code. 

For example, 

// KOTLIN
fun main(args: Array) {   
  val s1 = Sample(1, 2)
}
class Sample(a : Int , b: Int) {   
  val p: Int   
  var q: Int   
  // initializer block   
  init {       
    p = a       
    q = b       
    println("The first parameter value is : $p")       
    println(\"The second parameter value is : $q\")   
  }
}

Output:-

The first parameter value is: 1
The second parameter value is: 2

Explanation - The values 1 and 2 are supplied to the constructor arguments a and b when the object s1 is created for the class Sample. In the class p and q, two attributes are specified. The initializer block is called when an object is created, and it not only sets up the attributes but also prints them to the standard output.

• Secondary Constructor - Secondary constructors allow for the initialization of variables as well as the addition of logic to the class. They have the constructor keyword prefixed to them. For example,

// KOTLIN
fun main(args: Array) {   
  val s1 = Sample(1, 2)
}
class Sample {   
  constructor(a: Int, b: Int) {       
    println("The first parameter value is : $p")       
    println("The second parameter value is : $q")   
  }
}

Output:-

The first parameter value is: 1
The second parameter value is: 2

The compiler determines which secondary constructor will be called based on the inputs provided. We don't specify which constructor to use in the above program, so the compiler chooses for us.

In Kotlin, a class can contain one or more secondary constructors and at most one primary constructor. The primary constructor initializes the class, while the secondary constructor initialises the class and adds some additional logic.

For example,

// KOTLIN
fun main(args: Array) {      
  var temp = "Interview"   
  when(temp) {       
    "Interview" -> println("Without Book is the solution.")       
    "Job" -> println("Interview is the solution.")       
    "Success" -> println("Hard Work is the solution.")   
  }
}

Output:-

Without Book is the solution.

Explanation:- In the above code, the variable temp has the value “Interview”. The when condition matches for the exact value as that of temp’s and executes the corresponding code statements. Thus, “Without Book is the solution” is printed.